using System;
using System.Collections.Generic; 
using System.Data; 
using System.Linq; 
using System.Windows.Forms;
using System.IO;
using System.Text.RegularExpressions;
using System.Collections;
namespace ArrayApp
{
    class ArrayClass
    {
        static void Main(string[] args){
            // 一维数组的创建及初始化
            int[] arrStart1 = { 1, 2, 3, 4, 5, 6, 7, 8 };
            int[] arrStart2 = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
            int[] arrStart3 = new int[8] { 1, 2, 3, 4, 5, 6, 7, 8 };
            ArrayList arrListStart1 = new ArrayList { 1,2,3}; // using System.Collections;
            Console.WriteLine("{0};{1};{2}", string.Join(",", arrStart1), string.Join(",", arrStart2), string.Join(",", arrStart3));
            foreach(int item in arrListStart1)
            {
                Console.WriteLine("ArrayList:{0}", item);
            }
            // 二维数组的创建及初始化
            int[,] arrStart4 = { { 1, 2, 3 }, { 3, 4, 5 } };
            // 获取数组的维度大小
            int rows = arrStart4.GetLength(0); // 有多少行
            int cols = arrStart4.GetLength(1); // 一行多少列

            // 使用嵌套循环遍历数组并打印每个元素
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < cols; j++)
                {
                    Console.Write(arrStart4[i, j] + " "); // 打印当前元素和一个空格
                }
                Console.WriteLine(); // 换行，以便下一行的元素在新的一行上打印
            }
            // 多维数组的创建及初始化
            int[,,] arrStartAll = new int[2, 5, 2] {
                {
                    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }
                },
                {
                    { 1, 2 }, { 1, 2 }, { 1, 2 }, { 1, 2 }, { 99, 99 }
                }
            };
            // 使用嵌套循环遍历三维数组并打印每个元素
            for (int i = 0; i < arrStartAll.GetLength(0); i++) // 第一维
            {
                for (int j = 0; j < arrStartAll.GetLength(1); j++) // 第二维
                {
                    for (int k = 0; k < arrStartAll.GetLength(2); k++) // 第三维
                    {
                        Console.Write(arrStartAll[i, j, k] + " "); // 打印当前元素
                    }
                    Console.WriteLine(); // 换行到下一行
                }
            }
            // 交错数组
            int[][] arrArr = new int[3][] { new int[] { 1, 3 }, new int[] { 1, 2, 3, 4 }, new int[] { -1, 2, 3, 4 } };
            for (int i = 0; i < arrArr.Length; i++)
            {
                Console.Write("交错数组:");
                for (int j = 0; j < arrArr[i].Length; j++)
                {
                    Console.Write(arrArr[i][j] + " ");
                }
                Console.WriteLine(); // 换行到下一行
            }
            // 数组的创建 - 同一类型变量集合
            byte[] arrByte = new byte[10];
            Console.WriteLine(string.Join(",", arrByte));
            int[] arrInt = new int[10];
            Console.WriteLine(string.Join(",", arrInt));
            double[] arrDouble = new double[10];
            Console.WriteLine(string.Join(",", arrDouble));
            char[] arrChar = new char[10];
            Console.WriteLine(string.Join(",", arrChar));
            // 数组的创建 - 泛型集合 - object
            object[] arrObject = new object[10];
            arrObject[0] = 123; // int
            arrObject[1] = "hello"; // string
            arrObject[2] = 3.14; // double
            Console.WriteLine("使用时需要显式转换: {0}", arrObject[1]);
            Console.WriteLine("object创建数组: {0}", string.Join(",", arrObject));
            int boolarrObject = (int?)arrObject[0] ?? 0;
            Console.WriteLine(boolarrObject);
            // 数组的创建 - 泛型集合 - IEnumerable
            List<int> intList = new List<int>();
            List<string> stringList = new List<string>();
            List<double> doubleList = new List<double>();

            intList.Add(456);
            stringList.Add("hello");
            doubleList.Add(3.14);

            // 使用IEnumerable迭代
            IEnumerable<object> mixedEnumerable = intList.Cast<object>().Concat(stringList.Cast<object>()).Concat(doubleList.Cast<object>()); // using System.Collections.Generic; 

            foreach (object item in mixedEnumerable)
            {
                // 根据需要处理不同类型的对象
                if (item is int)
                {
                    int intValue = (int)item;
                    // 处理int类型
                    Console.WriteLine(intValue);
                }
                else if (item is string)
                {
                    string stringValue = (string)item;
                    // 处理string类型
                    Console.WriteLine(stringValue);
                }
                else if (item is double)
                {
                    double doubleValue = (double)item;
                    // 处理double类型 
                    Console.WriteLine(doubleValue);
                }
            }
            // 数组的创建 - 泛型集合 - dynamic(不推荐用)
            dynamic[] arrDynanic = new dynamic[3];
            arrDynanic[0] = 789;
            foreach (var item in arrDynanic)
            {
                // 根据需要处理不同类型的对象
                if (item is int)
                {
                    int intValue = (int)item;
                    // 处理int类型
                    Console.WriteLine(intValue);
                }
                else if (item is string)
                {
                    string stringValue = (string)item;
                    // 处理string类型
                    Console.WriteLine(stringValue);
                }
                else if (item is double)
                {
                    double doubleValue = (double)item;
                    // 处理double类型 
                    Console.WriteLine(doubleValue);
                }
            }

            // Array 的属性
            int[] arrAttribute = new int[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            double[] arrAttributeDouble = new double[10];
            Console.WriteLine(arrAttribute.Length); // 获取一个 32 位整数，该值表示所有维度的数组中的元素总数。
            Console.WriteLine(arrAttributeDouble.LongLength); // 获取一个 64 位整数，该值表示所有维度的数组中的元素总数。
            Console.WriteLine("IsReadOnly:获取一个值，该值指示数组是否只读：{0}", arrAttributeDouble.IsReadOnly); // 获取一个值，该值指示数组是否只读。值为True 表示不可修改
            Console.WriteLine("IsFixedSize:获取一个值，该值指示数组是否带有固定大小 {0}", arrAttribute.IsFixedSize); // 获取一个值，该值指示数组是否带有固定大小，值为True 表示数组长度不可修改
            Console.WriteLine("显示数组中的维数:{0}", arrAttribute.Rank); // 显示数组中的维数
            Console.WriteLine("表示是否同步访问数组:{0}", arrAttribute.IsSynchronized); // 表示是否同步访问数组
            Console.WriteLine("获取同步访问数组的对象:{0}", arrAttribute.SyncRoot); // 表示是否同步访问数组
            /* Array 的方法 */
            // 获取数组的长度： GetLength，GetLongLength
            int[] arrAttributeNew = new int[10];
            Console.WriteLine(arrAttribute.GetLength(0)); // 多维数组获取数组的长度,32位
            Console.WriteLine(arrAttributeNew.GetLongLength(0)); // 多维数组获取数组的长度，64位
            // SetValue:修改数组元素的值，GetValue:获取数组对象的值
            for (int i = 0; i < arrAttributeNew.Length; i++)
            {
                Console.WriteLine(arrAttributeNew.GetValue(i));
                arrAttributeNew.SetValue(i + 1 + 10, i);  
            }
            Console.WriteLine(string.Join(" ", arrAttributeNew)); // 输出1 2 3 4 5 6 7 8 9 10
            // Copy:将数组一复制给数组二，修改数组二不影响到数组一的元素
            Array.Copy(arrAttribute, arrAttributeNew, arrAttributeNew.Length); // arrAttributeNew.Length 要小于 arrAttribute.Length
            Console.WriteLine("Copy 复制数组{0}", string.Join(" ", arrAttributeNew)); // 输出0 0 0 0 0 0 0 0 0 0
            // CopyTo:将一维数组一复制给数组二
            int[] arrAttributeCopyTo = new int[11];
            arrAttributeCopyTo.SetValue(999, 0);
            arrAttribute.CopyTo(arrAttributeCopyTo, 1); // 参数一：复制结果数组；参数二：下标从第几位开始复制
            Console.WriteLine("CopyTo 复制数组{0}", string.Join(" ", arrAttributeCopyTo)); // 输出0 0 0 0 0 0 0 0 0 0 

            // Clone 复制数组
            int[] arrAttributeClone = (int[])arrAttribute.Clone();
            Console.WriteLine("Clone 复制数组{0}",string.Join(" ", arrAttributeClone));

            // 动态数组ArrayList - 新增
            ArrayList arrayListData = new ArrayList(); // using System.Collections;
            arrayListData.Add("我是你的");
            arrayListData.Add(123);
            foreach (var item in arrayListData)
            {
                Console.WriteLine("Add后：{0}", item);
            }
            // 动态数组ArrayList - 插入
            arrayListData.Insert(0, "插入的元素1");
            arrayListData.Insert(2, "插入的元素2");
            arrayListData.Insert(2, "插入的元素3");
            arrayListData.Insert(2, "插入的元素4");
            foreach (var item in arrayListData)
            {
                Console.WriteLine("Insert后：{0}", item);
            }
            // 动态数组ArrayList - 移除
            arrayListData.Remove("插入的元素1"); // 或者 arrayListData.RemoveAt(0);
            foreach (var item in arrayListData)
            {
                Console.WriteLine("Remove后：{0}", item);
            }
            arrayListData.RemoveRange(0, 2);
            foreach (var item in arrayListData)
            {
                Console.WriteLine("Remove后：{0}", item);
            }
            // 排序
            int[] arrsort= new int[]{ 1, 2, 3, 4, 5, 6, 7, 5, 3 };
            Array.Sort(arrsort);
            Console.WriteLine(String.Join(" ",arrsort));
            // 逆转数组
            Array.Reverse(arrsort);
            Console.WriteLine(String.Join(" ", arrsort));

            // clear
            List<int> myList = new List<int> { 1, 2, 3, 4, 5 }; // using System.Collections.Generic;  
            Console.WriteLine("Original list:{0}", String.Join(" ", myList));
            myList.Clear();
            Console.WriteLine("Original list:{0}", String.Join(" ", myList));

        }
    }
}